Raspberry Pi Smart Home Manager

#main.py
import os
import RPi.GPIO as GPIO
import time
import pygame
from pygame.locals import *
from audiorecorder import *
import speech_recognition as sr
from helper import *
from helper import GPIO_helper
from datetime import datetime
from log import logDB
from facerecog import face_recog

# constant
HUMID_HIGH = 65
HUMID_LOW = 30

# instance of assistant classes
audio = Recorder()
recognizer = sr.Recognizer()
recognizer.dynamic_energy_threshold = True
GP = GPIO_helper()
log = logDB("LOG.db")
face = face_recog()

def audio_to_text(filename):
    speech = sr.AudioFile(filename)
    with speech as source:
        recognizer.adjust_for_ambient_noise(source)
        audio = recognizer.record(source)
        text = recognizer.recognize_google(audio,language = 'en-US')#,key = "AIzaSyBUHRjjkxUx-sj1ZC5jcOdwPBOXHscZW3I")
    return text

class GUI():
    layer_index = 1
    recording = 0


    # Initialize pygame and the piTFT display
    os.putenv('SDL_VIDEODRIVER', 'fbcon') # Display on piTFT 
    os.putenv('SDL_FBDEV', '/dev/fb1')
    os.putenv('SDL_MOUSEDRV', 'TSLIB') # Track mouse clicks on piTFT 
    os.putenv('SDL_MOUSEDEV', '/dev/input/touchscreen')
    pygame.init()
    pygame.mouse.set_visible(False)
    screen = pygame.display.set_mode((320, 240))

    # path for image log
    image_folder = '/home/pi/proj/photohistory'
    image_files = [file for file in os.listdir(image_folder) if file.startswith('image_') and file.endswith('.jpg')]
    image_files.sort()
    current_index = len(image_files) - 1

    # Define some colors and fonts
    BLACK = (0, 0, 0)
    WHITE = (255, 255, 255)
    RED = (255, 0, 0)
    GREEN = (0, 255, 0)
    BLUE = (0, 0, 255)
    ICE = (185,205,246)
    ORANGE = (255,165,0)
    PLANT = (169,207,83)
    BROWN = (204,102,51)
    FIRE = (226,88,34)
    WATER = (102,255,230)
    YELLOW = (255,255,0)
    VOICECOLOR = (0,0,255)
    FONT = pygame.font.SysFont('Arial', 20)
    width, height = 320,240
    
    # Define some buttons
    button1 = pygame.Rect(210, 170, 80, 60) # First layer button
    button2 = pygame.Rect(320 // 2 - 35, 240 - 50, 70, 40) # Second layer button
    voice_button = pygame.Rect(30,170,80,60)
    log_button = pygame.Rect(120,170,80,60)
    button_positions = [(width // 4, height//4), (3 * width // 4, height //4),
                            (width // 4, 4* height//6), (3* width // 4, 4* height //6)]
    circle_rect = []
    for position in button_positions:
        rect = pygame.draw.circle(screen, GREEN, position, 40)
        circle_rect.append(rect)

    # Define some variables to keep track of layers and appliance states
    current_layer = 1
    is_new_to_image = 0
    light_on = False
    curtain_open = False
    manual_humid = False
    humidifier_on = False
    manual_humid = False
    fan_on = False
    face_id = 0
    manual_control = False
    room1counter = 0
    room2counter = 1
    lastroom = 0
    curroom = 0
    temperature = 0
    humidity = 0

    # acquire some variables
    GP.dht_init()
    temperature, humidity = GP.humitemp()
    start_time = time.time()
    weather = acquire_Ithaca_weather()
    sunrise_today = sunrise()
    sunset_today = sunset()

    door_counter = 0

    def __init__(self):
        GPIO.setmode(GPIO.BCM)
        GPIO.setup(17, GPIO.IN, pull_up_down=GPIO.PUD_UP)
        GPIO.setup(22, GPIO.IN, pull_up_down=GPIO.PUD_UP)
        return
    
    # Define a function to draw the first layer
    def draw_first_layer(self):
        if(int(time.time()-self.start_time)%120 == 0):
            self.weather = acquire_Ithaca_weather()
        screen = self.screen
        FONT = self.FONT
        # Clear the screen
        screen.fill(self.BLACK)
        # Draw the button to go to the second layer
        pygame.draw.rect(self.screen, self.GREEN, self.button1)
        pygame.draw.rect(self.screen, self.VOICECOLOR, self.voice_button)
        pygame.draw.rect(self.screen, self.RED, self.log_button)        
        screen.blit(FONT.render('Log', True, self.WHITE), (140, 190))
        screen.blit(FONT.render('Voice', True, self.WHITE), (45, 190))
        screen.blit(FONT.render('Next', True, self.WHITE), (230, 190))
        # Get the current time, temperature and RH
        now = datetime.now() 
        current_time = now.strftime("%Y-%m-%d %H:%M:%S")        
        humidity, temperature = self.humidity, self.temperature
        # Display the time, temperature and RH
        weather_str = 'Temp: ' + str(self.weather[0])+' C, '+str(self.weather[1])
        if self.weather[0] <10 :
            screen.blit(FONT.render(weather_str, True, self.ICE), (30, 20))
        else :
            screen.blit(FONT.render(weather_str, True, self.ORANGE), (30, 20))
        screen.blit(FONT.render('Date&Time: ' + current_time, True, self.YELLOW), (20, 57))
        if temperature < 25 and temperature > 15:
            screen.blit(FONT.render('Room Temp: {:.1f} C'.format(temperature), True, self.ORANGE), (30, 95))
        elif temperature < 0:
            screen.blit(FONT.render('Room Temp: {:.1f} C'.format(temperature), True, self.ICE), (30, 95))
        else : 
            screen.blit(FONT.render('Room Temp: {:.1f} C'.format(temperature), True, self.FIRE), (30, 95))
        if humidity > HUMID_HIGH :
            screen.blit(FONT.render('RH: {:.1f} %'.format(humidity), True, self.WATER), (30, 131))
        elif humidity < HUMID_LOW:
            screen.blit(FONT.render('RH: {:.1f} %'.format(humidity), True, self.BROWN), (30, 131))
        else:
            screen.blit(FONT.render('RH: {:.1f} %'.format(humidity), True, self.PLANT), (30, 131))

        # Update the display
        pygame.display.flip()

    # Define a function to draw the second layer
    def draw_second_layer(self):
        width, height = 320, 240
        screen = self.screen
        FONT = self.FONT
        screen.fill(self.BLACK)

        # Display round buttons for curtain, humidifier, light, and voice control
        button_radius = 40
        
        for position in self.button_positions:
            pygame.draw.circle(self.screen, self.GREEN, position, button_radius)
        screen.blit(FONT.render('Curtain', True, self.WHITE), (width // 4-30, height//4-10))
        screen.blit(FONT.render('Light', True, self.WHITE), (3 * width // 4 -20, height //4-10))
        screen.blit(FONT.render('Humid', True, self.WHITE), (width // 4 -25, 4* height//6-10))
        screen.blit(FONT.render('Fan', True, self.WHITE), (3* width // 4 -23, 4* height //6-10))

        # Display 'Exit' button
        pygame.draw.rect(self.screen, self.RED, (width // 2 - 35, height - 50, 70, 40))
        exit_button_text = FONT.render('Exit', True, self.WHITE)
        screen.blit(exit_button_text, (width // 2 - exit_button_text.get_width() // 2, height-40))

        pygame.display.flip()

    # Define a function to draw the third layer
    def draw_third_layer(self):
        width, height = 320, 240
        screen = self.screen
        FONT = self.FONT
        screen.fill(self.BLACK)

        # Display round buttons for curtain, humidifier, light, and voice control
        button_radius = 40
        
        for position in self.button_positions:
            pygame.draw.circle(self.screen, self.BLUE, position, button_radius)

        screen.blit(FONT.render('Door', True, self.WHITE), (width // 4-25, height//4-10))
        screen.blit(FONT.render('Room', True, self.WHITE), (3 * width // 4 -25, height //4-10))
        screen.blit(FONT.render('Image', True, self.WHITE), (width // 4 -25, 4* height//6-10))
        screen.blit(FONT.render('Back', True, self.WHITE), (3* width // 4 -23, 4* height //6-10))

        pygame.display.flip()

    # Define a function to show the images on the screen
    def show_images(self):
        screen = self.screen

        self.image_files = [file for file in os.listdir(self.image_folder) if file.startswith('image_') and file.endswith('.jpg')]
        self.image_files = sorted(self.image_files, key=extract_number)
        if self.is_new_to_image == 0:
            self.current_index = len(self.image_files) - 1
        self.image_path = os.path.join(self.image_folder, self.image_files[self.current_index])
        image = pygame.image.load(self.image_path)
        image = pygame.transform.scale(image, (320, 240))
        image_rect = image.get_rect()
        screen_rect = screen.get_rect()
        image_rect.center = screen_rect.center
        screen.blit(image, image_rect)
        pygame.display.flip()
    
    # Define a function to draw the logt layer
    def draw_logs(self):
        screen = self.screen

        screen.fill(self.BLACK)  # Clear the screen
        font = pygame.font.Font(None, 24)  # Choose a font and size
        start_x = 10
        start_y = 10
        line_height = 25

        if self.layer_index == 5:
            logs = log.list_recent_entries_by_name_or_location_with_limit(9,location="DOOR")
            for count, cur in enumerate(logs):
                # Select the specified columns from the log entry
                selected_columns = [cur[index] for index in [2,3]]

                # Create the display string with the selected columns
                display_string = f'Log {count}: ' + ' | '.join(str(item) for item in selected_columns)

                # Render the text
                text = font.render(display_string, True, self.WHITE)
                screen.blit(text, (start_x, start_y + count * line_height))

            # Update the display
            pygame.display.flip()


        elif self.layer_index == 6:
            logs = log.list_recent_entries_by_name_or_location_with_limit(9,name="NONAME")
            for count, cur in enumerate(logs):
                # Select the specified columns from the log entry
                selected_columns = [cur[index] for index in [1,3]]

                # Create the display string with the selected columns
                display_string = f'Log {count}: ' + ' | '.join(str(item) for item in selected_columns)

                # Render the text
                text = font.render(display_string, True, self.WHITE)
                screen.blit(text, (start_x, start_y + count * line_height))

            # Update the display
            pygame.display.flip()

    # mainloop displaying all the GUI and conduct the finite state machine    
    def mainloop(self):
        code_run = True
        click_counter = 0
        time_limit = 1200
        # print(self.humidity)
        while code_run:    
            #exit button
            if not GPIO.input(17):
                GPIO.cleanup()
                pygame.quit()                
                exit()

            # sunrise set time update and check
            if(int(time.time()-self.start_time)%3600 == 0):
                self.sunrise_today = sunrise()
                self.sunset_today = sunset()
            current_time = datetime.now()
            time_difference1 = current_time - datetime.strptime(self.sunrise_today,'%H:%M:%S')
            time_difference2 = current_time - datetime.strptime(self.sunset_today,'%H:%M:%S')
            total_seconds1 = time_difference1.total_seconds()
            total_seconds2 = time_difference2.total_seconds()

            if abs(total_seconds1) < 1:
                if not self.curtain_open:
                    GP.curtain_open()
                    self.curtain_open = True
            elif  abs(total_seconds2) < 1:
                if self.curtain_open:
                    GP.curtain_close()
                    self.curtain_open = False
            
            # time out
            if time.time() -self.start_time > time_limit:
                print("timeout")
                code_run = False

            # three motion sensors
            if GP.motiondect1():
                # print("motion detected")
                # print("Layer Index :",self.layer_index)
                name, filepath = face.recognize(2)
                if not name == "No Face":
                    print(name+" detected")
                    # if name == "Unknown":
                    #     speak("Unknown person at door")
                    log.insert("DOOR",name,filepath)
                    GP.light3_duration()


            if GP.motiondect2():
                self.room1counter = (self.room1counter+1) % 1000
                if self.room1counter == 0:
                    self.curroom = 1
                    if not self.curroom == self.lastroom:
                        print("ROOM1")
                        GP.light1last()
                        log.insert("ROOM1","NONAME","None")
                    self.lastroom = 1

            if GP.motiondect3():
                self.room2counter = (self.room2counter+1) % 1000
                if self.room2counter == 0:
                    self.curroom = 2
                    if not self.curroom == self.lastroom:
                        print("ROOM2")
                        GP.light2last()
                        log.insert("ROOM2","NONAME","None")
                    self.lastroom = 2

            # button for face recognize
            if not GPIO.input(22):
                name, filepath = face.recognize(2)
                if not name == "No Face":
                    print(name+" detected")
                    # if name == "Unknown":
                    #     speak("Unknown person at door")
                    log.insert("DOOR",name,filepath)
                    GP.light3_duration()
                    speak(name + " is knocking at the door")

            # humidifier and fan control
            self.temperature, self.humidity = GP.humitemp()
            if self.humidity < HUMID_LOW: # and not self.manual_control:
                if not self.humidifier_on:
                    GP.humid_on()
                    self.humidifier_on = True
                if self.fan_on:
                    GP.fan_off()
                    self.fan_on = False

            if self.humidity > HUMID_HIGH:# and not self.manual_control:
                if self.humidifier_on:
                    GP.humid_off()
                    self.humidifier_on = False
                if not self.fan_on:
                    GP.fan_on()
                    self.fan_on = True

            # draw layers
            if self.layer_index == 1:
                self.draw_first_layer()
            elif self.layer_index == 2:
                self.draw_second_layer()
            elif self.layer_index == 3:
                self.draw_third_layer()
            elif self.layer_index == 4:
                self.show_images()
            elif self.layer_index == 5 or self.layer_index == 6:
                self.draw_logs()

            # click detection and state switch
            pos = 0,0
            for event in pygame.event.get(): 
                if(event.type == MOUSEBUTTONDOWN): 
                    pos = pygame.mouse.get_pos()
                    pygame.event.clear([pygame.MOUSEBUTTONDOWN])
                    if self.layer_index == 1:
                        print(pos)
                        if self.button1.collidepoint(pos):
                            self.layer_index = 2
                        elif self.voice_button.collidepoint(pos):
                            if self.recording == 0 :
                                audio.start()
                                self.recording = 1
                                print("recording start")
                                self.VOICECOLOR = self.YELLOW
                            elif self.recording == 1 :
                                self.VOICECOLOR = self.BLUE
                                audio.stop()
                                audio.save("recording")
                                self.recording = 0
                                print("recording stop")
                                command = "NONE"
                                try:
                                    command = audio_to_text("recording.wav")
                                    print(command)
                                except:
                                    print("fail to recognize")
                                    speak("fail to recognize")
                                if "curtain" in command :
                                    if not self.curtain_open:
                                        GP.curtain_open()
                                        self.curtain_open = True
                                    else :
                                        GP.curtain_close()
                                        self.curtain_open = False
                                elif "light" in command :
                                    if not self.light_on:
                                        GP.light_on(1)
                                        self.light_on = True
                                    else :
                                        GP.light_off(1)
                                        self.light_on = False
                                elif ("humid" in command or "humidifier" in command ):
                                    if not self.humidifier_on:
                                        GP.humid_on()
                                        self.humidifier_on = True
                                        self.manual_control = True
                                    else :
                                        GP.humid_off()
                                        self.humidifier_on = False
                                        if(not self.humidifier_on and not self.fan_on):                                        
                                            self.manual_control = False

                                elif "fan" in command or "fun" in command:
                                    if not self.fan_on:
                                        GP.fan_on()
                                        self.fan_on = True                                       
                                        self.manual_control = True
                                    else :
                                        GP.fan_off()
                                        self.fan_on = False
                                        if(not self.humidifier_on and not self.fan_on):                                        
                                            self.manual_control = False

                                elif ("weather" in command) or (("temperature" in command) and not ("room" in command)):
                                    temp, cond = acquire_Ithaca_weather()
                                    speak("Current temperature:" + str(temp) + "Celsius degree, Condition: "+ str(cond))
                                elif ("room temperature" in command) or ("humidity" in command):
                                    humid, roomtemp = self.humidity, self.temperature
                                    speak("Room temperature: "+str(roomtemp)+ "Celsius degree, Relative Humidity: "+str(humid)+"percent")
                                elif ("date" in command) or ("time" in command):
                                    now = datetime.now()
                                    datestring =  "it is " + str(now.strftime("%A, %B %d, %Y, %I:%M %p"))
                                    print(datestring)
                                    speak(datestring)
                                elif "image" in command:
                                    self.layer_index = 4
                                    self.is_new_to_image = 0
                                elif "door" in command:
                                    self.layer_index = 5
                                elif "room" in command:
                                    self.layer_index = 6
                                elif command == "terminate":
                                    GPIO.cleanup()

                        elif self.log_button.collidepoint(pos):
                            self.layer_index = 3
                    elif self.layer_index == 2:
                        if self.button2.collidepoint(pos):
                                self.layer_index = 1
                        if self.circle_rect[0].collidepoint(pos):
                            if not self.curtain_open:
                                GP.curtain_open()
                                self.curtain_open = True
                            else:
                                GP.curtain_close()
                                self.curtain_open = False
                        if self.circle_rect[1].collidepoint(pos):
                            if not self.light_on:
                                GP.light_on(1)
                                self.light_on = True
                            else:
                                GP.light_off(1)
                                self.light_on = False
                        if self.circle_rect[2].collidepoint(pos):
                            if not self.humidifier_on:
                                GP.humid_on()
                                self.humidifier_on = True                                        
                                self.manual_control = True
                            else:
                                GP.humid_off()
                                self.humidifier_on = False
                                if(not self.humidifier_on and not self.fan_on):                                        
                                    self.manual_control = False
                        if self.circle_rect[3].collidepoint(pos):
                            if not self.fan_on:
                                GP.fan_on()
                                self.fan_on = True                                        
                                self.manual_control = True
                            else:
                                GP.fan_off()
                                self.fan_on = False             
                                if(not self.humidifier_on and not self.fan_on):                                        
                                    self.manual_control = False
                    elif self.layer_index == 3:
                        if self.circle_rect[0].collidepoint(pos):
                            self.layer_index = 5
                        if self.circle_rect[1].collidepoint(pos):
                            self.layer_index = 6
                        if self.circle_rect[2].collidepoint(pos):
                            self.layer_index = 4
                            self.is_new_to_image = 0
                        if self.circle_rect[3].collidepoint(pos):
                            self.layer_index = 1

                    elif self.layer_index == 4:
                        mouse_x, mouse_y = event.pos
                        if 100 < mouse_x < 220:
                            self.layer_index = 3
                        elif mouse_x < 100: 
                            self.is_new_to_image = 1
                            self.current_index = (self.current_index - 1) % len(self.image_files)
                        elif mouse_x > 220:
                            self.is_new_to_image = 1
                            self.current_index = (self.current_index + 1) % len(self.image_files)
                    elif self.layer_index == 5 or self.layer_index ==6:
                        click_counter = (click_counter+1)%2
                        if(click_counter == 0):
                            self.layer_index = 3
                        
menu = GUI()
try:
    menu.mainloop()
except KeyboardInterrupt:
    GPIO.cleanup()
    pygame.quit()
    exit()

#helper.py
import requests
import os
import threading
import time
import RPi.GPIO as GPIO
import board
import digitalio
from astral import LocationInfo
from datetime import datetime
from astral.sun import sun
import adafruit_dht
import re

DURATION = 5

# a class that controls all GPIOs
class GPIO_helper():
    GPIO.setmode(GPIO.BCM)

    servo1_pin = 6

    GPIO.setup(servo1_pin, GPIO.OUT)

    pwm1 = GPIO.PWM(servo1_pin, 50)

    pwm1.start(0)

    fan_pin = 4

    GPIO.setup(fan_pin, GPIO.OUT)
    GPIO.output(fan_pin, GPIO.LOW)

    humid_pin = 20

    GPIO.setup(humid_pin, GPIO.OUT)
    GPIO.output(humid_pin, GPIO.LOW)

    pir_sensor1 = digitalio.DigitalInOut(board.D23)
    pir_sensor1.direction = digitalio.Direction.INPUT

    pir_sensor2 = digitalio.DigitalInOut(board.D12)
    pir_sensor2.direction = digitalio.Direction.INPUT

    pir_sensor3 = digitalio.DigitalInOut(board.D16)
    pir_sensor3.direction = digitalio.Direction.INPUT

    led_pin_1 = 19
    led_pin_2 = 21
    led_pin_3 = 5
    GPIO.setup(led_pin_1, GPIO.OUT)
    GPIO.setup(led_pin_2, GPIO.OUT)
    GPIO.setup(led_pin_3, GPIO.OUT)


    dhtDevice = dht_start()
    temperature, humidity = 0, 0
    dht_lock = threading.Lock()
    def __init__(self):
        return
    def curtain_open(self):
        threading._start_new_thread(self.curtain_open_helper,())

    def curtain_close_helper(self):
        try:
            self.pwm1.ChangeDutyCycle(8.5)

            time.sleep(1)

            self.pwm1.ChangeDutyCycle(0)
            print("curtain closed")

        except KeyboardInterrupt:
            self.pwm1.stop()
            self.GPIO.cleanup()

    def curtain_close(self):
        threading._start_new_thread(self.curtain_close_helper,())

    def curtain_open_helper(self):
        try:
            self.pwm1.ChangeDutyCycle(6.5)

            time.sleep(1.1)

            self.pwm1.ChangeDutyCycle(0)
            print("curtain open")

        except KeyboardInterrupt:
            self.pwm1.stop()
            self.GPIO.cleanup()
            
    def humid_on(self):
        time.sleep(0.3)
        threading._start_new_thread(self.humid_on_helper,())

    def humid_on_helper(self):
        print("humid on")
        GPIO.output(self.humid_pin, GPIO.HIGH)
        time.sleep(0.3)
        GPIO.output(self.humid_pin, GPIO.LOW)
        time.sleep(0.3)
        GPIO.output(self.humid_pin, GPIO.HIGH)
        time.sleep(0.3)
        GPIO.output(self.humid_pin, GPIO.LOW)
        
    def humid_off(self):
        time.sleep(0.3)
        threading._start_new_thread(self.humid_off_helper,())

    def humid_off_helper(self):
        print("humid off")
        GPIO.output(self.humid_pin, GPIO.HIGH)
        time.sleep(0.3)
        GPIO.output(self.humid_pin, GPIO.LOW)

    def light1last(self):
        threading._start_new_thread(self.light1_duration,())

    def light2last(self):
        threading._start_new_thread(self.light2_duration,())

    def light1_duration(self):
        self.light_on(1)
        time.sleep(DURATION)
        self.light_off(1)

    def light2_duration(self):
        self.light_on(2)
        time.sleep(DURATION)
        self.light_off(2)

    def light3_duration(self):
        self.light_on(3)
        time.sleep(DURATION)
        self.light_off(3)


    def light_on(self,index):
        if index == 1:
            # print("light1 on")
            GPIO.output(self.led_pin_1, GPIO.HIGH)
        elif index == 2:
            # print("light2 on")
            GPIO.output(self.led_pin_2, GPIO.HIGH)
        elif index ==3 :
            GPIO.output(self.led_pin_3, GPIO.HIGH)

        
    def light_off(self,index):
        if index == 1:
            # print("light1 off")
            GPIO.output(self.led_pin_1, GPIO.LOW)
        elif index == 2:
            # print("light2 off")
            GPIO.output(self.led_pin_2, GPIO.LOW)
        elif index ==3 :
            GPIO.output(self.led_pin_3, GPIO.LOW)

    def fan_on(self):
        print("fan on")
        GPIO.output(self.fan_pin, GPIO.HIGH)

    def fan_off(self):
        print("fan off")
        GPIO.output(self.fan_pin, GPIO.LOW)

    def motiondect1(self):
        return self.pir_sensor1.value
    
    def motiondect2(self):
        return self.pir_sensor2.value
    
    def motiondect3(self):
        return self.pir_sensor3.value
    
    def humitemp(self):
        #self.dht_lock.acquire()
        a,b = self.temperature, self.humidity
        #self.dht_lock.release()
        if a == None :
            a = 999
        if b == None :
            b = 999
        return a,b

    def dht_init(self):
        threading._start_new_thread(self.dht_helper,())

    def dht_helper(self):
        while True:
            try:
                # Print the values to the serial port
                #self.dht_lock.acquire()
                self.temperature = self.dhtDevice.temperature
                self.humidity = self.dhtDevice.humidity
                #self.dht_lock.release()
                time.sleep(0.1)
            except RuntimeError as error:
                # Errors happen fairly often, DHT's are hard to read, just keep going
                time.sleep(0.1)
                continue
            except Exception as error:
                self.dhtDevice.exit()
                raise error
    
def speak(text):
    print(text)
    os.system("echo "+text+" > speechfifo")

# request current weahter from api
def get_weather(api_key, lat, lon):
    url = f'http://api.weatherapi.com/v1/current.json?key={api_key}&q={lat},{lon}'
    response = requests.get(url)

    if response.status_code == 200:
        weather_data = response.json()
        return weather_data
    else:
        print(f"Error: Unable to fetch weather data. Status code: {response.status_code}")
        return None

def acquire_Ithaca_weather():
    api_key = 'YOUR API KEY'
    latitude, longitude = 42.443962, -76.501884 
    weather_data = get_weather(api_key, latitude, longitude)
    return weather_data['current']['temp_c'], weather_data['current']['condition']['text']

def sunrise():
    city = LocationInfo("Ithaca", "US", "US/Eastern", 42.443962, -76.501884)
    s = sun(city.observer, date=datetime.now(), tzinfo=city.timezone)
    return s['sunrise'].strftime('%H:%M:%S')


def sunset():
    city = LocationInfo("Ithaca", "US", "US/Eastern", 42.443962, -76.501884)
    s = sun(city.observer, date=datetime.now(), tzinfo=city.timezone)
    return s['sunset'].strftime('%H:%M:%S')

def extract_number(filename):
    parts = re.findall(r'\d+', filename)
    return int(parts[0]) if parts else None


def dht_start():
    while True:
        try:
            sensor = adafruit_dht.DHT11(board.D26)
            return sensor
        except Exception as e:
            print(f"Failed to initialize DHT11 sensor: {e}. Retrying...")
            time.sleep(0.5)  # Wait for 2 seconds before retrying

#audiorecorder.py
import pyaudio
import time
import threading
import wave

 
class Recorder:
    def __init__(self, chunk=4*1024, channels=1, rate=44100):
        self.CHUNK = chunk
        self.FORMAT = pyaudio.paInt16
        self.CHANNELS = channels
        self.RATE = rate
        self._running = True
        self._frames = []
 
    # start a thread to record
    def start(self):
        threading._start_new_thread(self.__recording,())
 
    # record
    def __recording(self):
        self._running = True
        self._frames = []
        p = pyaudio.PyAudio()
        stream = p.open(format=self.FORMAT,
                        channels=self.CHANNELS,
                        rate=self.RATE,
                        input=True,
                        frames_per_buffer=self.CHUNK)
        while self._running:
            data = stream.read(self.CHUNK)
            self._frames.append(data)
 
        stream.stop_stream()
        stream.close()
        p.terminate()
 
    # stop recording
    def stop(self):
        self._running = False
 
    # save the files
    def save(self, filename = "voice"):
 
        p = pyaudio.PyAudio()
        if not filename.endswith(".wav"):
            filename = filename + ".wav"
        wf = wave.open(filename, 'wb')
        wf.setnchannels(self.CHANNELS)
        wf.setsampwidth(p.get_sample_size(self.FORMAT))
        wf.setframerate(self.RATE)
        wf.writeframes(b''.join(self._frames))
        wf.close()
        print("Saved")

#playsound.py
import os
from gtts import gTTS
import time
fifo_path = 'speechfifo'

# read command from fifo and play it
while True:
    with open(fifo_path, 'r') as fifo_file:
    # read from fifo
        data = fifo_file.read()
        print("Spoke: "+data)
        if(data == 'exit'):
            exit()
        tts = gTTS(text=data, lang='en')
        tts.save("speech.mp3")
        os.system("nohup mpg123 speech.mp3 > playerlog.txt 2>&1 &")
        time.sleep(1)

#log.py
import sqlite3
from datetime import datetime

# a class of database that stores two kinds of log together
class logDB:
    def __init__(self, db_name):
        self.conn = sqlite3.connect(db_name)
        self.cursor = self.conn.cursor()
        self.create_table()

    def create_table(self):
        self.cursor.execute('''
            CREATE TABLE IF NOT EXISTS rooms (
                id INTEGER PRIMARY KEY,
                location TEXT NOT NULL,
                name TEXT NOT NULL,
                time TEXT NOT NULL,
                photo_file_name TEXT NOT NULL
            )
        ''')
        self.conn.commit()

    def insert(self, location, name, photo_file_name):
        if not photo_file_name:
            raise ValueError("photo_file_name cannot be null")
        current_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        self.cursor.execute('''
            INSERT INTO rooms (location, name, time, photo_file_name)
            VALUES (?, ?, ?, ?)
        ''', (location, name, current_time, photo_file_name))
        self.conn.commit()

    def remove(self, entry_id):
        self.cursor.execute('DELETE FROM rooms WHERE id = ?', (entry_id,))
        self.conn.commit()

    def search_on_room(self, location):
        self.cursor.execute('SELECT * FROM rooms WHERE location = ?', (location,))
        return self.cursor.fetchall()

    def search_on_name(self, name):
        self.cursor.execute('SELECT * FROM rooms WHERE name = ?', (name,))
        return self.cursor.fetchall()

    def traverse(self):
        self.cursor.execute('SELECT * FROM rooms')
        return self.cursor.fetchall()

    def list_recent_entries(self, count=3):
        self.cursor.execute('SELECT * FROM rooms ORDER BY time DESC LIMIT ?', (count,))
        return self.cursor.fetchall()

    def list_recent_entries_by_name_or_location_with_limit(self, n, name=None, location=None):
        query = 'SELECT * FROM rooms WHERE '
        params = []
        
        if name and location:
            query += 'name = ? AND location = ? '
            params.extend([name, location])
        elif name:
            query += 'name = ? '
            params.append(name)
        elif location:
            query += 'location = ? '
            params.append(location)
        else:
            return []  # No name or location provided, return empty list

        query += 'ORDER BY time DESC LIMIT ?'
        params.append(n)
        self.cursor.execute(query, params)
        return self.cursor.fetchall()

    def traverse_recent_entries_with_photo(self, n):
        self.cursor.execute('''
            SELECT * FROM rooms
            WHERE photo_file_name != 'None'
            ORDER BY time DESC
            LIMIT ?
        ''', (n,))
        return self.cursor.fetchall()

    def clean_database(self):
        self.cursor.execute('DELETE FROM rooms')
        self.conn.commit()

    def close(self):
        self.conn.close()


log = logDB("ROOM.db")
log.clean_database()

#train.py
import cv2
import os
import numpy as np
from PIL import Image
import time

# Path for face image database
path = '/home/pi/proj/dataset'
 
recognizer = cv2.face.LBPHFaceRecognizer_create()
detector = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
 
# function to get the images and label data
def getImagesAndLabels(path):
    imagePaths = [os.path.join(path,f) for f in os.listdir(path)]     
    faceSamples=[]
    ids = []
    for imagePath in imagePaths:
        PIL_img = Image.open(imagePath).convert('L') # convert it to grayscale
        img_numpy = np.array(PIL_img,'uint8')
        id = int(os.path.split(imagePath)[-1].split(".")[1])
        faces = detector.detectMultiScale(img_numpy)
        for (x,y,w,h) in faces:
            faceSamples.append(img_numpy[y:y+h,x:x+w])
            ids.append(id)
    return faceSamples,ids
 
print ("\n [INFO] Training faces. It will take a few seconds. Wait ...")
faces,ids = getImagesAndLabels(path)
recognizer.train(faces, np.array(ids))
 
# Save the model into trainer/trainer.yml
recognizer.write('trained_faces.yml') # recognizer.save() worked on Mac, but not on Pi
 
# Print the numer of faces trained and end program
print("\n [INFO] {0} faces trained. Exiting Program".format(len(np.unique(ids))))

#facerecog.py
import cv2
import numpy as np
import os 

class face_recog():
    recognizer = cv2.face.LBPHFaceRecognizer_create()
    recognizer.read('trained_faces.yml')
    faceCascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
    
    image_path = '/home/pi/proj/my_photo.jpg'
    folder_path = '/home/pi/proj/photohistory'
    font = cv2.FONT_HERSHEY_SIMPLEX
    
    # names related to ids
    names = ['Unknown', 'Zidong'] 
    
    # Initialize and start realtime video capture
    
    # Define min window size to be recognized as a face
    def __init__(self):
        return

    
    def recognize(self,threshold):
        cam = cv2.VideoCapture(0)
        cam.set(3, 640) # set video widht
        cam.set(4, 480) # set video height
        minW = 0.1*cam.get(3)
        minH = 0.1*cam.get(4)
    
        counter = {"Unknown": 0, "Zidong": 0}

        #iniciate id counter
        id = 0 
        frame = 0
        code_run = True
        while code_run:
            ret, img =cam.read()
            gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
            
            faces = self.faceCascade.detectMultiScale( 
                gray,
                scaleFactor = 1.1,
                minNeighbors = 3,
                minSize = (int(minW), int(minH)),
            )

            for(x,y,w,h) in faces:
                cv2.rectangle(img, (x,y), (x+w,y+h), (0,255,0), 2)
                id, confidence = self.recognizer.predict(gray[y:y+h,x:x+w])
        
                # Check if confidence is less than 100 ==> "0" is perfect match 
                if (confidence < 100):                  
                    name = self.names[id]
                    counter[name] = counter[name] + 1
                else:
                    counter["Unknown"] = counter["Unknown"] + 1
        
            k = cv2.waitKey(10) & 0xff # Press 'ESC' for exiting video
            if k == 27:
                break
            frame += 1 
            if frame >= 10 :
                code_run = False
        
        if (counter['Zidong']+counter['Unknown'] == 0) :
            return 'No Face' , "None"  # no face
        else :
            existing_images = [int(filename.split('_')[1].split('.')[0]) for filename in os.listdir(self.folder_path) if filename.endswith('.jpg')]
            max_index = max(existing_images) if existing_images else 0

            ret, frame = cam.read()

            image_path = os.path.join(self.folder_path, f"image_{max_index + 1}.jpg")
            cam.release()
            if counter['Unknown'] > threshold:
                cv2.imwrite(image_path, frame)
                return 'Unknown' , image_path
            elif counter["Zidong"] > threshold:
                cv2.imwrite(image_path, frame)
                return 'Zidong' , image_path #Unknown
            else:
                return 'No Face' , "None"  # no face

if __name__ == "__main__":
    face = face_recog()
    while True:
        a, b = face.recognize(2)
        print(a,b)

#shutdown.py
import RPi.GPIO as GPIO
import os

GPIO.setmode(GPIO.BCM)

GPIO.setup(27,GPIO.IN,pull_up_down=GPIO.PUD_UP)

def shutdown(channel):
    GPIO.cleanup()
    os.system("sudo shutdown -h now")

GPIO.add_event_detect(27, GPIO.FALLING, callback=shutdown, bouncetime=300)

try:
    while True:
        pass
except KeyboardInterrupt:

    GPIO.cleanup()